#include <cstring>
#include <cmath>
#include <iostream>  //预处理器指令 a PREPROCESSOR directive

#include <vector>
#include <array>
#include <new>
#include <valarray>

using namespace std; // 使定义可见   make definitions visible


/*
    ex16的栈模版使用指针类型会存在问题

    这里兼容指针类型(说明: 14.4.3)

    区别在与构造函数使用动态数组
    这涉及到在内部使用动态数组，因此，Stack类需要包含一个析构函数、一个复制构造函数和一个赋值运算符。

 */

template <class Type>
class Stack
{
private:
    enum {SIZE = 10};    // default size
    int stacksize;
    Type * items;       // holds stack items
    int top;            // index for top stack item
public:
    explicit Stack(int ss = SIZE);
    Stack(const Stack & st);
    ~Stack() { delete [] items; }
    bool isempty() { return top == 0; }
    bool isfull() { return top == stacksize; }
    bool push(const Type & item);   // add item to stack
    bool pop(Type & item);          // pop top into item
    Stack & operator=(const Stack & st);
};

template <class Type>
Stack<Type>::Stack(int ss) : stacksize(ss), top(0)
{
    items = new Type [stacksize];
}

template <class Type>
Stack<Type>::Stack(const Stack & st)
{
    stacksize = st.stacksize;
    top = st.top;
    items = new Type [stacksize];
    for (int i = 0; i < top; i++)
        items[i] = st.items[i];
}

template <class Type>
bool Stack<Type>::push(const Type & item)
{
    if (top < stacksize)
    {
        items[top++] = item;
        return true;
    }
    else
        return false;
}

template <class Type>
bool Stack<Type>::pop(Type & item)
{
    if (top > 0)
    {
        item = items[--top];
        return true;
    }
    else
        return false;
}

template <class Type>
Stack<Type> & Stack<Type>::operator=(const Stack<Type> & st)
{
    if (this == &st)
        return *this;
    delete [] items;
    stacksize = st.stacksize;
    top = st.top;
    items = new Type [stacksize];
    for (int i = 0; i < top; i++)
        items[i] = st.items[i];
    return *this; 
}




/*
This routine outputs an error message based on an error code supplied by the calling routine.
The way it outputs the message depends on the current processing state,which it retrieves on its own.
It returns a value indicating success or failure.
本子程序将根据调用方子程序所提供的错误码输出对应的错误信息。用于输出信息的方式与当前的处理状态有关，这将由子程序自己来判断。它会返回一个值来表明执行是成功还是失败。

*/

class Status{

};

class ErrorCode {};

class Message {};

Message LookupErrorMessage(ErrorCode code){};

Status Status_Failure;

Status ReportErrorMessage(ErrorCode errorToReport) //方法声明,函数声明
{

    // set the default status to "fail"(将默认状态设置为“失败”)
    // look up the message based on the error code(根据错误代码查找消息)
    // 这是填入的代码。
   Status errorMessagestatus = Status_Failure;

    // if the error code is valid(如果错误代码有效)
    // if doing interactive processing,display the error message interactively and declare success
    // 如果进行交互处理，则以交互方式显示错误消息并声明成功
    // 这里是一个新变量 errorMessage。
   Message errorMessage = LookupErrorMessage(errorToReport );


    //   if doing command line processing,log the error message to the command line and declare success
    //   (如果进行命令行处理，请将错误消息记录到命令行并声明成功)

    // (如果错误代码无效，请通知用户检测到内部错误)
    // if the error code isn't valid,notify the user that an internal error has been detected

    // return status information(返回状态信息)
    Status result;
    return result;
}















































